/**
 *
 */
package com.block.common.util;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.math.RoundingMode;

/**
 * 
 * BigDecimal工具
 */
public class BigDecimalUtil {

	/**
	 * 小数位数处理
	 */
	public static BigDecimal getDisplayAmount(BigDecimal amount, Integer digit){
		if (ObjectUtil.isEmpty(digit)){
			return amount;
		}
		if (ObjectUtil.isEmpty(amount)){
			return BigDecimal.ZERO;
		}
		return amount.setScale(digit, RoundingMode.DOWN);
	}


	/**
	 * 去掉末尾无效的0
	 * @param amount
	 * @return
	 */
	public static String removeEndZero(BigDecimal amount){
		if (ObjectUtil.isEmpty(amount)){
			amount = BigDecimal.ZERO;
		}
		return amount.stripTrailingZeros().toPlainString();
	}

	/**
	 * 减【一字符串一BigDecimal】
	 * 返回【字符串】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static String subtract(String valueOne, BigDecimal valueTwo)
	{
		return new BigDecimal(valueOne).subtract(valueTwo).toString();
	}

	/**
	 * 减【两BigDecimal】
	 * 返回【long】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static Long subtract(BigDecimal valueOne, BigDecimal valueTwo)
	{
		return valueOne.subtract(valueTwo).longValue();
	}
	/**
	 * 减【两BigDecimal】
	 * 返回【long】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static BigDecimal subtractReturnBigDecimal(BigDecimal valueOne, BigDecimal valueTwo)
	{
		return valueOne.subtract(valueTwo);
	}
	/**
	 * 减【一个Decimal一个字符串】
	 * 返回【long】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static Long subtractReturnLong(BigDecimal valueOne, String valueTwo)
	{
		return valueOne.subtract(new BigDecimal(valueTwo)).longValue();
	}

	/**
	 * 减【一个Decimal一个字符串】
	 * 返回【double】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static Double subtractReturnDouble(BigDecimal valueOne, String valueTwo)
	{
		return valueOne.subtract(new BigDecimal(valueTwo)).doubleValue();
	}

	/**
	 * 减【两字符串】
	 * 返回【字符串】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static String subtract(String valueOne, String valueTwo)
	{
		return new BigDecimal(valueOne).subtract(new BigDecimal(valueTwo)).toString();
	}

	/**
	 * 减【一个decimal一个字符串】
	 * 返回【字符串】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static String subtract(BigDecimal valueOne, String valueTwo)
	{
		return valueOne.subtract(new BigDecimal(valueTwo)).toString();
	}

	/**
	 * 减【一个decimal一个字符串】
	 * 返回【decimal】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static BigDecimal subtractReturnDecimal(BigDecimal valueOne, String valueTwo)
	{
		return valueOne.subtract(new BigDecimal(valueTwo));
	}

	/**
	 * 减【一个字符串一个decimal】
	 * 返回【decimal】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static BigDecimal subtractReturnDecimal(String valueOne, BigDecimal valueTwo)
	{
		return new BigDecimal(valueOne).subtract(valueTwo);
	}

	/**
	 * 减【两个decimal】
	 * 返回【decimal】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static BigDecimal subtractReturnDecimal(BigDecimal valueOne, BigDecimal valueTwo)
	{
	    if (valueOne == null){
	        valueOne = BigDecimal.ZERO;
        }
        if (valueTwo == null){
            valueTwo = BigDecimal.ZERO;
        }
		return valueOne.subtract(valueTwo);
	}

	/**
	 * 乘【一个decimal一个字符串】
	 * 返回【字符串】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static String multiply(BigDecimal valueOne, String valueTwo)
	{
		return valueOne.multiply(new BigDecimal(valueTwo)).toString();
	}

	/**
	 * 乘【一个decimal一个int】
	 * 返回【BigDecimal】
	 * 【返回金额】四舍五入
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static BigDecimal multiply(BigDecimal valueOne, int valueTwo, int stayNumber)
	{
		return valueOne.multiply(new BigDecimal(valueTwo)).setScale(stayNumber, BigDecimal.ROUND_HALF_UP);
	}

	/**
	 * 乘【两个字符串】
	 * 返回【decimal】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static BigDecimal multiplyReturnDecimal(String valueOne, String valueTwo)
	{
		return new BigDecimal(valueOne).multiply(new BigDecimal(valueTwo));
	}

	/**
	 * 乘【两个字符串】
	 * 返回【decimal】
	 * 【金额格式】1.445 -> 1.44
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static BigDecimal multiplyReturnDecimalNormal(String valueOne, String valueTwo)
	{
		return new BigDecimal(valueOne).multiply(new BigDecimal(valueTwo)).setScale(2, BigDecimal.ROUND_DOWN);
	}

	/**
	 * 乘【一个decimal一个字符串】
	 * 返回【decimal】对象
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static BigDecimal multiplyReturnDecimal(BigDecimal valueOne, String valueTwo)
	{
		return valueOne.multiply(new BigDecimal(valueTwo));
	}

	/**
	 * 乘【两个decimal】
	 * 返回【decimal】对象
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static BigDecimal multiplyReturnDecimal(BigDecimal valueOne, BigDecimal valueTwo)
	{
		return valueOne.multiply(valueTwo);
	}

	/**
	 * 加【两字符串】
	 * 返回【字符串】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static String add(String valueOne, String valueTwo)
	{
		return new BigDecimal(valueOne).add(new BigDecimal(valueTwo)).toString();
	}

	/**
	 * 加【两decimal】
	 * 返回【字符串】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static BigDecimal add(BigDecimal valueOne, BigDecimal valueTwo)
	{
		if (valueOne == null){
			valueOne = BigDecimal.ZERO;
		}
		if (valueTwo == null){
			valueTwo = BigDecimal.ZERO;
		}
		return valueOne.add(valueTwo);
	}
	/**
	 * 加【decimal】
	 * 返回【字符串】
	 * @return
	 */
	public static BigDecimal add(BigDecimal ... bigDecimals)
	{
		BigDecimal amount = BigDecimal.ZERO;
		for (BigDecimal bigDecimal:bigDecimals){
			if (bigDecimal == null){
				bigDecimal = BigDecimal.ZERO;
			}
			amount.add(bigDecimal);
		}
		return amount;
	}


	/**
	 * 加【两decimal】
	 * 返回【BigDecimal】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static BigDecimal addReturnDecimal(BigDecimal valueOne, BigDecimal valueTwo)
	{
		return valueOne.add(valueTwo);
	}

	/**
	 * 加【一个decimal一个字符串】
	 * 返回【字符串】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static String add(BigDecimal valueOne, String valueTwo)
	{
		return valueOne.add(new BigDecimal(valueTwo)).toString();
	}

	/**
	 * 加【一个decimal一个字符串】
	 * 返回【decimal】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static BigDecimal addReturnDecimal(BigDecimal valueOne, String valueTwo)
	{
		return valueOne.add(new BigDecimal(valueTwo));
	}

	/**
	 * 除【两个字符串】
	 * 返回【字符串】
	 * 设置保留位数
	 * @param valueOne
	 * @param valueTwo
	 * @param stayNumber
	 * @return
	 * 2017年1月3日 下午6:02:07
	 */
	public static String divide(String valueOne, String valueTwo,
			int stayNumber)
	{
		return new BigDecimal(valueOne).divide(new BigDecimal(valueTwo))
			.setScale(stayNumber, BigDecimal.ROUND_HALF_UP).toString();
	}

	/**
	 * 除【一个double一个字符串】
	 * 返回【double】
	 * 设置保留位数
	 * 【四舍五入】
	 * @param valueOne
	 * @param valueTwo
	 * @param stayNumber
	 * @return
	 * 2017年1月3日 下午6:02:07
	 */
	public static double divide(double valueOne, String valueTwo,
			int stayNumber)
	{
		return new BigDecimal(valueOne).divide(new BigDecimal(valueTwo))
			.setScale(stayNumber, BigDecimal.ROUND_HALF_UP).doubleValue();
	}

	/**
	 * 除【一个整形，一个字符串】
	 * 返回【decimal】
	 * 设置保留位数
	 * @param valueOne
	 * @param valueTwo
	 * @param stayNumber
	 * @return
	 * 2017年1月3日 下午6:02:07
	 */
	public static BigDecimal divide(int valueOne, String valueTwo,
			int stayNumber)
	{
		return new BigDecimal(valueOne).divide(new BigDecimal(valueTwo))
			.setScale(stayNumber, BigDecimal.ROUND_HALF_UP);
	}

	/**
	 * 分 转元
	 * @param amount
	 * @return
	 * 2016年11月18日 上午10:31:11
	 */
	public static String fen2Yuan(String amount)
	{
		BigDecimal bigDecimal=new BigDecimal(amount).divide(new BigDecimal("100"));
		return bigDecimal.setScale(2,BigDecimal.ROUND_DOWN).toString();
	}

	/**
	 *
	 * @param amount
	 * @return
	 * 2016年11月18日 上午10:31:11
	 */
	public static String getPointAmount(BigDecimal amount)
	{
//		String amountStr = amount.toString();
		BigDecimal bigDecimal=amount.multiply(new BigDecimal("100"));

//		if (amountStr.indexOf('.') > 0)
//		{
//			amountStr = amount.toString().replace(".", "");
//			return Integer.parseInt(amountStr) + "";
//		}
		return bigDecimal.setScale(2, RoundingMode.HALF_UP)+"";
	}

	/**
	 * 元转分
	 *
	 * @param amountStr
	 * @return
	 * 2016年11月18日 上午10:31:11
	 */
	public static String getPointAmount(String amountStr)
	{
		BigDecimal bigDecimal=new BigDecimal(amountStr);

		return getPointAmount(bigDecimal);
	}

	/**
	 * 得到非空的 BigDecimal
	 * @param amountStr
	 * @return
	 */
	public static BigDecimal getNotNullAmount(String amountStr){
		if (StrUtil.isEmpty(amountStr)){
			return BigDecimal.ZERO;
		}
		return new BigDecimal(amountStr);
	}

	/**
	 * 比较【两字符串】
	 * 返回【int】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static int compare(String valueOne, String valueTwo)
	{
		return new BigDecimal(valueOne).compareTo(new BigDecimal(valueTwo));
	}

	/**
	 * 比较【一decimal一字符串】
	 * 返回【int】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static int compare(BigDecimal valueOne, String valueTwo)
	{
		return valueOne.compareTo(new BigDecimal(valueTwo));
	}

	/**
	 * 比较【两个decimal】
	 * 返回【int】
	 * @param valueOne
	 * @param valueTwo
	 * @return
	 */
	public static int compare(BigDecimal valueOne, BigDecimal valueTwo)
	{
		return valueOne.compareTo(valueTwo);
	}

	/**
	 * 截取金额
	 * 【四舍五入】
	 * @param money
	 * @param cutLength 【保留的长度】
	 * @return
	 * 2017年5月2日 下午3:47:08
	 */
	public static String cutMoney(BigDecimal money, int cutLength)
	{
		return money.setScale(cutLength, BigDecimal.ROUND_HALF_UP).toString();
	}


	/**
	 * 保留四位小数，四舍五入，被除数为空时返回除数
	 * @param divisor
	 * @param dividend
	 * @return
	 */
	public static BigDecimal divide_4_halfup(BigDecimal divisor,BigDecimal dividend){
		if (dividend == null || dividend.compareTo(BigDecimal.ZERO) == 0){
			return BigDecimal.ONE;
		}
		if (divisor == null){
			return BigDecimal.ONE;
		}
		return divisor.divide(dividend,4, RoundingMode.HALF_UP);
	}

	/**
	 * 保留四位小数，四舍五入，被除数为空时返回除数
	 * @param divisor
	 * @param dividend
	 * @return
	 */
	public static BigDecimal divide_4_halfup_ret0(BigDecimal divisor,BigDecimal dividend){
		if (dividend == null || dividend.compareTo(BigDecimal.ZERO) == 0){
			return BigDecimal.ZERO;
		}
		if (divisor == null){
			return BigDecimal.ZERO;
		}
		return divisor.divide(dividend,4, RoundingMode.HALF_UP);
	}

	/**
	 * 获取非空对象，
	 * @param bigDecimal
	 * @return 若为空，则返回 BigDecimal.ZERO
	 */
	public static BigDecimal getNotNulBigDecimal(BigDecimal bigDecimal){
		if (bigDecimal == null){
			return BigDecimal.ZERO;
		}
		return bigDecimal;
	}

	/**
	 * 10的n次幂
	 * @param decimal 输入小数
	 * @param pow n次幂
	 * @return 整数
	 */
	public static BigInteger pow(BigDecimal decimal, int pow){
		return decimal.multiply(BigDecimal.TEN.pow(pow)).toBigInteger();
	}

	/**
	 * n位有效数字
	 * @param decimal 输入数
	 * @param precision 有效位数
	 * @return BigDecimal
	 */
	public static BigDecimal precision(BigDecimal decimal, int precision){
		return decimal.round(new MathContext(precision, RoundingMode.DOWN));
	}

	/**
	 * n位小数
	 * @param decimal 输入数
	 * @param precision 有效小数位位数
	 * @return BigDecimal
	 */
	public static BigDecimal scale(BigDecimal decimal, int precision){
		return decimal.setScale(precision, RoundingMode.DOWN);
	}
	/**
	 * n位小数或者n位有效数字
	 * @param decimal 输入数
	 * @param precision 有效位数
	 * @return BigDecimal
	 */
	public static BigDecimal precisionScale(BigDecimal decimal, int precision){
		if (decimal.compareTo(BigDecimal.ONE)>=0)
			return scale(decimal,precision);
		return precision(decimal,precision);
	}


	public static void main(String[] args) {
		String s = removeEndZero(new BigDecimal(1.00000000000000));
//		System.out.println(getPointAmount(new BigDecimal("24.00")));
//		System.out.println(getPointAmount(new BigDecimal("24.25")));
//		System.out.println(getPointAmount(new BigDecimal("24.00")));
//		System.out.println(getPointAmount(new BigDecimal("24.00")));
//		System.out.println(getPointAmount(new BigDecimal("24.02")));
//		System.out.println(getPointAmount(new BigDecimal("0.02")));
//		System.out.println(getPointAmount(new BigDecimal("1535.00")));
//		System.out.println(divide("153555", "100", 2));
//		System.out.println(add("-1", "5"));
//		System.out.println(add("10", "0.12"));
//		System.out.println(new BigDecimal("0.0264").setScale(2,BigDecimal.ROUND_DOWN));
		//System.out.println(cutMoney(new BigDecimal(0.1250), 2));
		System.out.println(divide(15.2, "3", 2));
	}

}
